package org.wu.framework.lazy.orm.database.lambda.stream.condition.update;

import org.wu.framework.core.utils.ObjectUtils;
import org.wu.framework.lazy.orm.core.persistence.util.LazySQLUtil;
import org.wu.framework.lazy.orm.database.lambda.stream.function.Snippet;

import java.lang.reflect.ParameterizedType;
import java.util.concurrent.ConcurrentHashMap;

public abstract class AbstractUpdateSetValueBasicComparison<T> implements UpdateSetValueBasicComparison<T, Snippet<T, ?>, Object,AbstractUpdateSetValueBasicComparison<T>> {


    protected ConcurrentHashMap<String,Object> setValue = new ConcurrentHashMap<>();


    /**
     * 设置数据
     *
     * @param condition 判断条件
     * @param row       数据行
     * @param value     数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> set(boolean condition, Snippet<T, ?> row, Object value) {
        if (condition) {
            String rowName = columnToString(row);
            setValue.putIfAbsent(rowName, LazySQLUtil.valueToSqlValue(value));
        }
        return this;
    }

    /**
     * 设置数据
     *
     * @param row   数据行
     * @param value 数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> set(Snippet<T, ?> row, Object value) {
        return set(true, row, value);
    }

    /**
     * 设置数据忽略空
     *
     * @param row   数据行
     * @param value 数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> setIgnoreEmpty(Snippet<T, ?> row, Object value) {
        return set(ObjectUtils.isNotEmpty(value), row, value);
    }

    /**
     * 设置数据
     *
     * @param condition 判断条件
     * @param rowName   数据行
     * @param value     数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> set(boolean condition, String rowName, Object value) {
        if (condition) {
            setValue.putIfAbsent(rowName, LazySQLUtil.valueToSqlValue(value));
        }
        return this;
    }

    /**
     * 设置数据
     *
     * @param rowName   数据行
     * @param value 数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> set(String rowName, Object value) {
        return set(true, rowName, value);
    }

    /**
     * 设置数据忽略空
     *
     * @param rowName 数据行
     * @param value   数据
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> setIgnoreEmpty(String rowName, Object value) {
        return set(ObjectUtils.isNotEmpty(value), rowName, value);
    }

    /**
     * 设置表达式
     *
     * @param row   数据行
     * @param value 表达式
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> setExpression(Snippet<T, ?> row, Object value) {
        String rowName = columnToString(row);
        setValue.putIfAbsent(rowName, value);
        return this;
    }

    /**
     * 设置表达式
     *
     * @param rowName   数据行
     * @param value 表达式
     * @return 当前对象
     */
    @Override
    public AbstractUpdateSetValueBasicComparison<T> setExpression(String rowName, Object value) {
        setValue.putIfAbsent(rowName, value);
        return this;
    }

    /**
     * 获取 set value 数据
     *
     * @return set value 数据
     */
    @Override
    public ConcurrentHashMap<String, Object> setValue() {
        return setValue;
    }

    /**
     * 获取T 的class
     *
     * @return
     */
    @Override
    public Class<T> getClassT() {
        ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
        Class<T> type = (Class<T>) superClass.getActualTypeArguments()[0];
        return type;
    }

    /**
     * 列到字符串 表名.子段名
     *
     * @param row
     * @return
     */
    protected abstract String columnToString(Snippet<T, ?> row ) ;
}
